官方網站#
基本類型#
布林值#
最基本的數據類型就是簡單的 true/false 值，在 JavaScript 和 TypeScript 裡叫做boolean（其它語言中也一樣）。
let isDone: boolean = false;
數字#
和 JavaScript 一樣，TypeScript 裡的所有數字都是浮點數。 這些浮點數的類型是 number。 除了支持十進制和十六進制字面量，TypeScript 還支持 ECMAScript 2015 中引入的二進制和八進制字面量。
let decLiteral: number = 6;
let hexLiteral: number = 0xf00d;
let binaryLiteral: number = 0b1010;
let octalLiteral: number = 0o744;
字串#
JavaScript 程序的另一項基本操作是處理網頁或伺服器端的文本數據。 像其它語言裡一樣，我們使用 string表示文本數據類型。 和 JavaScript 一樣，可以使用雙引號（ "）或單引號（'）表示字串。
let name: string = "bob";
name = "smith";
你還可以使用模版字串，它可以定義多行文本和內嵌表達式。 這種字串是被反引號包圍（ `），並且以${ expr }這種形式嵌入表達式
let name: string = `Gene`;
let age: number = 37;
let sentence: string = `Hello, my name is ${ name }.
I'll be ${ age + 1 } years old next month.`;
這與下面定義sentence的方式效果相同：
let sentence: string = "Hello, my name is " + name + ".\n\n" +
"I'll be " + (age + 1) + " years old next month.";
陣列#
TypeScript 像 JavaScript 一樣可以操作陣列元素。 有兩種方式可以定義陣列。 第一種，可以在元素類型後面接上 []，表示由此類型元素組成的一個陣列：
let list: number[] = [1, 2, 3];
第二種方式是使用陣列泛型，Array <元素類型>：
let list: Array<number> = [1, 2, 3];
元組 Tuple#
元組類型允許表示一個已知元素數量和類型的陣列，各元素的類型不必相同。 比如，你可以定義一對值分別為 string和number類型的元組。
// Declare a tuple type
let x: [string, number];
// Initialize it
x = ['hello', 10]; // OK
// Initialize it incorrectly
x = [10, 'hello']; // Error
當訪問一個已知索引的元素，會得到正確的類型：
console.log(x[0].substr(1)); // OK
console.log(x[1].substr(1)); // Error, 'number' does not have 'substr'
當訪問一個越界的元素，會使用聯合類型替代：
x[3] = 'world'; // OK, 字串可以賦值給(string | number)類型
console.log(x[5].toString()); // OK, 'string' 和 'number' 都有 toString
x[6] = true; // Error, 布林不是(string | number)類型
聯合類型是高級主題，我們會在以後的章節裡討論它。
列舉 enum#
enum類型是對 JavaScript 標準數據類型的一個補充。 像 C# 等其它語言一樣，使用列舉類型可以為一組數值賦予友好的名字。
enum Color {Red, Green, Blue}
let c: Color = Color.Green;
默認情況下，從0開始為元素編號。 你也可以手動的指定成員的數值。 例如，我們將上面的例子改成從 1開始編號：
enum Color {Red = 1, Green, Blue}
let c: Color = Color.Green;
或者，全部都採用手動賦值：
enum Color {Red = 1, Green = 2, Blue = 4}
let c: Color = Color.Green;
列舉類型提供的一個便利是你可以由列舉的值得到它的名字。 例如，我們知道數值為 2，但是不確定它映射到 Color 裡的哪個名字，我們可以查找相應的名字：
enum Color {Red = 1, Green, Blue}
let colorName: string = Color[2];
console.log(colorName); // 顯示'Green'因為上面代碼裡它的值是2
Any 任意類型#
有時候，我們會想要為那些在編程階段還不清楚類型的變數指定一個類型。 這些值可能來自於動態的內容，比如來自用戶輸入或第三方代碼庫。 這種情況下，我們不希望類型檢查器對這些值進行檢查而是直接讓它們通過編譯階段的檢查。 那麼我們可以使用 any類型來標記這些變數：
let notSure: any = 4;
notSure = "maybe a string instead";
notSure = false; // okay, definitely a boolean
在對現有代碼進行改寫的時候，any類型是十分有用的，它允許你在編譯時可選地包含或移除類型檢查。 你可能認為 Object有相似的作用，就像它在其它語言中那樣。 但是 Object類型的變數只是允許你給它賦任意值 - 但是卻不能夠在它上面調用任意的方法，即便它真的有這些方法：
let notSure: any = 4;
notSure.ifItExists(); // okay, ifItExists might exist at runtime
notSure.toFixed(); // okay, toFixed exists (but the compiler doesn't check)
let prettySure: Object = 4;
prettySure.toFixed(); // Error: Property 'toFixed' doesn't exist on type 'Object'.
當你只知道一部分數據的類型時，any類型也是有用的。 比如，你有一個陣列，它包含了不同的類型的數據：
let list: any[] = [1, true, "free"];
list[1] = 100;
Void 無返回值#
某種程度上來說，void類型像是與any類型相反，它表示沒有任何類型。 當一個函數沒有返回值時，你通常會見到其返回值類型是 void：
function warnUser(): void {
console.log("This is my warning message");
}
聲明一個void類型的變數沒有什麼大用，因為你只能為它賦予undefined和null：
let unusable: void = undefined;
Null 和 Undefined#
TypeScript 裡，undefined和null兩者各自有自己的類型分別叫做undefined和null。 和 void相似，它們的本身的類型用處不是很大：
// Not much else we can assign to these variables!
let u: undefined = undefined;
let n: null = null;
默認情況下null和undefined是所有類型的子類型。 就是說你可以把 null和undefined賦值給number類型的變數。
然而，當你指定了--strictNullChecks標記，null和undefined只能賦值給void和它們各自。 這能避免 很多常見的問題。 也許在某處你想傳入一個 string或null或undefined，你可以使用聯合類型string | null | undefined。 再次說明，稍後我們會介紹聯合類型。
注意：我們鼓勵盡可能地使用--strictNullChecks，但在本手冊裡我們假設這個標記是關閉的。
Never#
never類型表示的是那些永不存在的值的類型。 例如， never類型是那些總是會拋出異常或根本就不會有返回值的函數表達式或箭頭函數表達式的返回值類型； 變數也可能是 never類型，當它們被永不為真的類型保護所約束時。
never類型是任何類型的子類型，也可以賦值給任何類型；然而，沒有類型是never的子類型或可以賦值給never類型（除了never本身之外）。 即使 any也不可以賦值給never。
下面是一些返回never類型的函數：
// 返回never的函數必須存在無法達到的終點
function error(message: string): never {
throw new Error(message);
}
// 推斷的返回值類型為never
function fail() {
return error("Something failed");
}
// 返回never的函數必須存在無法達到的終點
function infiniteLoop(): never {
while (true) {
}
}
Object 對象#
object表示非原始類型，也就是除number，string，boolean，symbol，null或undefined之外的類型。
使用object類型，就可以更好的表示像Object.create這樣的 API。例如：
declare function create(o: object | null): void;
create({ prop: 0 }); // OK
create(null); // OK
create(42); // Error
create("string"); // Error
create(false); // Error
create(undefined); // Error
類型斷言#
有時候你會遇到這樣的情況，你會比 TypeScript 更了解某個值的詳細信息。 通常這會發生在你清楚地知道一個實體具有比它現有類型更確切的類型。
通過類型斷言這種方式可以告訴編譯器，“相信我，我知道自己在幹什麼”。 類型斷言好比其它語言裡的類型轉換，但是不進行特殊的數據檢查和解構。 它沒有運行時的影響，只是在編譯階段起作用。 TypeScript 會假設你，程序員，已經進行了必須的檢查。
類型斷言有兩種形式。 其一是 “尖括號” 語法：
let someValue: any = "this is a string";
let strLength: number = (<string>someValue).length;
另一個為as語法：
let someValue: any = "this is a string";
let strLength: number = (someValue as string).length;
介面#
介紹#
TypeScript 的核心原則之一是對值所具有的結構進行類型檢查。 它有時被稱做 “鴨式辨型法” 或 “結構性子類型化”。 在 TypeScript 裡，介面的作用就是為這些類型命名和為你的代碼或第三方代碼定義契約。
介面初探#
下面通過一個簡單示例來觀察介面是如何工作的
function printLabel(labelledObj: { label: string }) {
console.log(labelledObj.label);
}
let myObj = { size: 10, label: "Size 10 Object" };
printLabel(myObj);
類型檢查器會查看printLabel的調用。 printLabel有一個參數，並要求這個對象參數有一個名為label類型為string的屬性。 需要注意的是，我們傳入的對象參數實際上會包含很多屬性，但是編譯器只會檢查那些必需的屬性是否存在，並且其類型是否匹配。 然而，有些時候 TypeScript 卻並不會這麼寬鬆，我們下面會稍做講解。
下面我們重寫上面的例子，這次使用介面來描述：必須包含一個label屬性且類型為string：
interface LabelledValue {
label: string;
}
function printLabel(labelledObj: LabelledValue) {
console.log(labelledObj.label);
}
let myObj = {size: 10, label: "Size 10 Object"};
printLabel(myObj);
LabelledValue介面就好比一個名字，用來描述上面例子裡的要求。 它代表了有一個 label屬性且類型為string的對象。 需要注意的是，我們在這裡並不能像在其它語言裡一樣，說傳給 printLabel的對象實現了這個介面。 我們只會去關注值的外形。 只要傳入的對象滿足上面提到的必要條件，那麼它就是被允許的。
還有一點值得提的是，類型檢查器不會去檢查屬性的順序，只要相應的屬性存在並且類型也是對的就可以。
可選屬性#
介面裡的屬性不全都是必需的。 有些是只在某些條件下存在，或者根本不存在。 可選屬性在應用 “option bags” 模式時很常用，即給函數傳入的參數對象中只有部分屬性賦值了。
下面是應用了 “option bags” 的例子：
interface SquareConfig {
color?: string;
width?: number;
}
function createSquare(config: SquareConfig): {color: string; area: number} {
let newSquare = {color: "white", area: 100};
if (config.color) {
newSquare.color = config.color;
}
if (config.width) {
newSquare.area = config.width * config.width;
}
return newSquare;
}
let mySquare = createSquare({color: "black"});
帶有可選屬性的介面與普通的介面定義差不多，只是在可選屬性名字定義的後面加一個?符號。
可選屬性的好處之一是可以對可能存在的屬性進行預定義，好處之二是可以捕獲引用了不存在的屬性時的錯誤。 比如，我們故意將 createSquare裡的color屬性名拼錯，就會得到一個錯誤提示：
interface SquareConfig {
color?: string;
width?: number;
}
function createSquare(config: SquareConfig): { color: string; area: number } {
let newSquare = {color: "white", area: 100};
if (config.clor) {
// Error: Property 'clor' does not exist on type 'SquareConfig'
newSquare.color = config.clor;
}
if (config.width) {
newSquare.area = config.width * config.width;
}
return newSquare;
}
let mySquare = createSquare({color: "black"});
只讀屬性#
一些對象屬性只能在對象剛剛創建的時候修改其值。 你可以在屬性名前用 readonly來指定只讀屬性:
interface Point {
readonly x: number;
readonly y: number;
}
你可以通過賦值一個對象字面量來構造一個Point。 賦值後， x和y再也不能被改變了。
let p1: Point = { x: 10, y: 20 };
p1.x = 5; // error!
TypeScript 具有ReadonlyArray類型，它與Array相似，只是把所有可變方法去掉了，因此可以確保陣列創建後再也不能被修改：
let a: number[] = [1, 2, 3, 4];
let ro: ReadonlyArray<number> = a;
ro[0] = 12; // error!
ro.push(5); // error!
ro.length = 100; // error!
a = ro; // error!
上面代碼的最後一行，可以看到就算把整個ReadonlyArray賦值到一個普通陣列也是不可以的。 但是你可以用類型斷言重寫：
a = ro as number[];
readonly vs const#
最簡單判斷該用readonly還是const的方法是看要把它做為變數使用還是做為一個屬性。 做為變數使用的話用 const，若做為屬性則使用readonly。
額外的屬性檢查#
我們在第一個例子裡使用了介面，TypeScript 讓我們傳入{ size: number; label: string; }到僅期望得到{ label: string; }的函數裡。 我們已經學過了可選屬性，並且知道他們在 “option bags” 模式裡很有用。
然而，天真地將這兩者結合的話就會像在 JavaScript 裡那樣搬起石頭砸自己的腳。 比如，拿 createSquare例子來說：